﻿using DevExpress.XtraEditors;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Ces.Entity;
using MESQWinform;
using Newtonsoft.Json;

namespace MesProjectWinform.BasicData.基础实现.显示页面
{
    public partial class jianup : DevExpress.XtraEditors.XtraForm
    {
        // 定义事件委托，用于通知主窗体数据已更新
        public delegate void DataUpdatedEventHandler();
        public event DataUpdatedEventHandler DataUpdated;
        
        // 保存当前车间ID
        private long _workshopId;
        
        // 保存原始数据，用于重置功能
        private WorkShop _originalWorkshop;
        
        // 默认构造函数
        public jianup()
        {
            InitializeComponent();
        }
        
        // 带参数的构造函数，接收车间ID
        public jianup(long id)
        {
            InitializeComponent();
            _workshopId = id;
            
            // 初始化默认车间对象，避免空引用异常
            _originalWorkshop = new WorkShop
            {
                Id = id,
                CreatedTime = DateTime.Now,
                UpdatedTime = DateTime.Now
            };
            
            // 加载表单时获取数据
            this.Load += Jianup_Load;
        }
        
        // 新增：带完整参数的构造函数，直接接收车间所有信息
        public jianup(long id, string code, string name, string description)
        {
            InitializeComponent();
            _workshopId = id;
            
            // 使用传入的参数创建车间对象
            _originalWorkshop = new WorkShop
            {
                Id = id,
                Workshopcode = code,
                Workshopname = name,
                Workshopdescription = description,
                CreatedTime = DateTime.Now,
                UpdatedTime = DateTime.Now
            };
            
            // 表单加载时直接显示数据，不再从API获取
            this.Load += (s, e) => DisplayWorkshopData(_originalWorkshop);
        }
        
        // 表单加载事件
        private async void Jianup_Load(object sender, EventArgs e)
        {
            // 显示等待光标
            this.Cursor = Cursors.WaitCursor;

            try
            {
                // 初始化空控件，防止加载延迟时界面空白
                if (textEdit1 != null) textEdit1.Text = "";
                if (textEdit2 != null) textEdit2.Text = "";
                if (memoEdit1 != null) memoEdit1.Text = "";

                // 静默加载数据
                await LoadWorkshopData();
            }
            catch (Exception)
            {
                // 静默处理异常，不显示任何提示
                // 确保显示默认的空表单
                DisplayDefaultWorkshop();
            }
            finally
            {
                // 恢复正常光标
                this.Cursor = Cursors.Default;
            }
        }
        
        // 将动态JSON数据转换为WorkShop对象
        private WorkShop ConvertToWorkshop(dynamic data)
        {
            try
            {
                return new WorkShop
                {
                    Id = Convert.ToInt64(data.id ?? data.Id),
                    IsDeleted = Convert.ToBoolean(data.isDeleted ?? data.IsDeleted ?? false),
                    CreatedBy = Convert.ToString(data.createdBy ?? data.CreatedBy ?? ""),
                    CreatedTime = Convert.ToDateTime(data.createdTime ?? data.CreatedTime ?? DateTime.Now),
                    UpdatedBy = Convert.ToString(data.updatedBy ?? data.UpdatedBy ?? ""),
                    UpdatedTime = Convert.ToDateTime(data.updatedTime ?? data.UpdatedTime ?? DateTime.Now),
                    Workshopcode = Convert.ToString(data.workshopcode ?? data.Workshopcode ?? ""),
                    Workshopname = Convert.ToString(data.workshopname ?? data.Workshopname ?? ""),
                    Workshopdescription = Convert.ToString(data.workshopdescription ?? data.Workshopdescription ?? ""),
                    Workshopattributes = Convert.ToString(data.workshopattributes ?? data.Workshopattributes ?? "")
                };
            }
            catch(Exception)
            {
                // 静默处理异常，返回默认对象
                return new WorkShop
                {
                    Id = _workshopId,
                    CreatedTime = DateTime.Now,
                    UpdatedTime = DateTime.Now
                };
            }
        }
        
        // 统一处理异常 - 仅记录日志，不显示提示
        private void HandleException(Exception ex, string prefix)
        {
            // 仅输出到控制台或日志文件，不显示给用户
            Console.WriteLine($"{prefix}: {ex.Message}");
            if (ex.InnerException != null)
            {
                Console.WriteLine($"详细信息: {ex.InnerException.Message}");
            }
        }

        // 显示默认的空车间数据
        private void DisplayDefaultWorkshop()
        {
            _originalWorkshop = new WorkShop
            {
                Id = _workshopId,
                CreatedTime = DateTime.Now,
                UpdatedTime = DateTime.Now,
                Workshopcode = "",
                Workshopname = "",
                Workshopdescription = ""
            };
            
            // 显示空的表单
            DisplayWorkshopData(_originalWorkshop);
        }
        
        // 从API加载车间数据
        private async Task LoadWorkshopData()
        {
            try
            {
                // 显示加载指示器或禁用控件
                this.UseWaitCursor = true;
                
                // 方法1：先尝试使用主表查询接口获取所有车间数据，再筛选出特定ID的车间
                string url = "api/WorkShop/GetWorkShop";
                string json = await APIClientl.CallApiAsync(url);
                
                Console.WriteLine($"方法1 - 查询所有车间返回: {json}");
                
                if (!string.IsNullOrWhiteSpace(json))
                {
                    try
                    {
                        // 使用强类型解析
                        WorkShopDto workshopDto = JsonConvert.DeserializeObject<WorkShopDto>(json);
                        
                        if (workshopDto != null && workshopDto.Data != null && workshopDto.Data.Count > 0)
                        {
                            // 使用LINQ查找指定ID的车间
                            WorkShop workshop = workshopDto.Data.FirstOrDefault(w => w.Id == _workshopId);
                            
                            if (workshop != null)
                            {
                                // 找到匹配ID的车间
                                _originalWorkshop = workshop;
                                DisplayWorkshopData(_originalWorkshop);
                                Console.WriteLine($"方法1成功: ID={_workshopId}, 名称={workshop.Workshopname}");
                                return;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"方法1异常: {ex.Message}");
                        // 继续尝试其他方法
                    }
                }
                
                // 方法2：尝试直接使用ID作为参数查询
                url = $"api/WorkShop/GetWorkShop?id={_workshopId}";
                json = await APIClientl.CallApiAsync(url);
                
                Console.WriteLine($"方法2 - 根据ID查询返回: {json}");
                
                if (!string.IsNullOrWhiteSpace(json))
                {
                    try
                    {
                        // 使用强类型解析
                        WorkShopDto workshopDto = JsonConvert.DeserializeObject<WorkShopDto>(json);
                        
                        if (workshopDto != null && workshopDto.Data != null && workshopDto.Data.Count > 0)
                        {
                            // 使用第一个数据
                            _originalWorkshop = workshopDto.Data[0];
                            DisplayWorkshopData(_originalWorkshop);
                            Console.WriteLine($"方法2成功: ID={_originalWorkshop.Id}, 名称={_originalWorkshop.Workshopname}");
                            return;
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"方法2异常: {ex.Message}");
                        // 继续尝试其他方法
                    }
                }
                
                // 方法3：尝试使用GetWorkShopById接口
                url = $"api/WorkShop/GetWorkShopById?id={_workshopId}";
                json = await APIClientl.CallApiAsync(url);
                
                Console.WriteLine($"方法3 - GetWorkShopById返回: {json}");
                
                if (!string.IsNullOrWhiteSpace(json))
                {
                    try
                    {
                        dynamic result = JsonConvert.DeserializeObject<dynamic>(json);
                        
                        if (result != null && result.Data != null)
                        {
                            if (result.Data is Newtonsoft.Json.Linq.JArray)
                            {
                                var dataArray = result.Data as Newtonsoft.Json.Linq.JArray;
                                if (dataArray.Count > 0)
                                {
                                    _originalWorkshop = ConvertToWorkshop(dataArray[0]);
                                    DisplayWorkshopData(_originalWorkshop);
                                    Console.WriteLine($"方法3成功(数组): ID={_originalWorkshop.Id}");
                                    return;
                                }
                            }
                            else
                            {
                                _originalWorkshop = ConvertToWorkshop(result.Data);
                                DisplayWorkshopData(_originalWorkshop);
                                Console.WriteLine($"方法3成功(单对象): ID={_originalWorkshop.Id}");
                                return;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"方法3异常: {ex.Message}");
                    }
                }
                
                // 如果以上方法都失败，显示默认空表单
                Console.WriteLine($"所有方法都失败，显示默认表单");
                DisplayDefaultWorkshop();
            }
            catch (Exception ex)
            {
                // 记录错误到日志
                Console.WriteLine($"LoadWorkshopData总异常: {ex.Message}");
                // 显示默认表单
                DisplayDefaultWorkshop();
            }
            finally
            {
                // 恢复正常光标
                this.UseWaitCursor = false;
            }
        }
        
        // 将车间数据显示到表单控件中
        private void DisplayWorkshopData(WorkShop workshop)
        {
            try
            {
                if (workshop == null)
                {
                    // 如果数据为空，清空所有控件
                    if (textEdit1 != null) textEdit1.Text = "";
                    if (textEdit2 != null) textEdit2.Text = "";
                    if (memoEdit1 != null) memoEdit1.Text = "";
                    return;
                }
                
                // 设置窗体标题
                this.Text = !string.IsNullOrEmpty(workshop.Workshopname) 
                    ? $"修改车间 - {workshop.Workshopname}" 
                    : "修改车间";
                
                // 显示车间信息到相应控件
                if (textEdit1 != null) 
                {
                    // 确保不为null且去掉前后空格
                    textEdit1.Text = (workshop.Workshopcode ?? "").Trim();
                    
                    // 设置编号文本框为只读，因为编号是自动生成的不可修改
                    textEdit1.Properties.ReadOnly = true;
                    
                    // 显示工具提示，帮助用户识别原始值
                    if (!string.IsNullOrEmpty(workshop.Workshopcode))
                    {
                        textEdit1.ToolTip = $"原始编码: {workshop.Workshopcode}";
                    }
                    
                    // 选中文本，便于修改
                    textEdit1.SelectAll();
                }
                
                if (textEdit2 != null) 
                {
                    textEdit2.Text = (workshop.Workshopname ?? "").Trim();
                    
                    // 显示工具提示
                    if (!string.IsNullOrEmpty(workshop.Workshopname))
                    {
                        textEdit2.ToolTip = $"原始名称: {workshop.Workshopname}";
                    }
                }
                
                if (memoEdit1 != null) 
                {
                    memoEdit1.Text = (workshop.Workshopdescription ?? "").Trim();
                    
                    // 显示工具提示
                    if (!string.IsNullOrEmpty(workshop.Workshopdescription))
                    {
                        memoEdit1.ToolTip = $"原始描述: {workshop.Workshopdescription}";
                    }
                }
                
                // 将焦点设置到第一个输入框
                if (textEdit1 != null && textEdit1.CanFocus)
                {
                    textEdit1.Focus();
                }
                
                // 显示一个状态标签，指示正在编辑的是哪个车间
                UpdateStatusLabel($"正在编辑: 车间 {workshop.Workshopname} ({workshop.Workshopcode})");
            }
            catch
            {
                // 静默处理显示异常
            }
        }
        
        // 显示状态信息
        private void UpdateStatusLabel(string message)
        {
            try
            {
                // 查找状态标签控件
                Label statusLabel = this.Controls.OfType<Label>().FirstOrDefault(l => l.Name == "statusLabel");
                
                // 如果不存在则创建一个
                if (statusLabel == null)
                {
                    statusLabel = new Label();
                    statusLabel.Name = "statusLabel";
                    statusLabel.AutoSize = false;
                    statusLabel.TextAlign = ContentAlignment.MiddleLeft;
                    statusLabel.Dock = DockStyle.Bottom;
                    statusLabel.Height = 22;
                    statusLabel.BackColor = Color.LightBlue;
                    statusLabel.ForeColor = Color.Navy;
                    this.Controls.Add(statusLabel);
                }
                
                // 更新消息
                statusLabel.Text = "  " + message;
            }
            catch
            {
                // 忽略任何异常
            }
        }
        
        // 触发数据更新事件的方法
        protected void OnDataUpdated()
        {
            DataUpdated?.Invoke();
        }

        private void jianup_Load_1(object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void button2_Click(object sender, EventArgs e)
        {
            try
            {
                // 先检查数据有效性但不提示错误
                if (string.IsNullOrEmpty(textEdit1.Text.Trim()))
                {
                    textEdit1.Focus();
                    // 提示信息
                    UpdateStatusLabel("车间编码不能为空，请输入");
                    return;
                }
                
                if (string.IsNullOrEmpty(textEdit2.Text.Trim()))
                {
                    textEdit2.Focus();
                    // 提示信息
                    UpdateStatusLabel("车间名称不能为空，请输入");
                    return;
                }
                
                // 检查数据是否有变化
                bool hasChanges = false;
                
                if (_originalWorkshop.Workshopcode != textEdit1.Text.Trim() || 
                    _originalWorkshop.Workshopname != textEdit2.Text.Trim() || 
                    _originalWorkshop.Workshopdescription != memoEdit1.Text.Trim())
                {
                    hasChanges = true;
                }
                
                if (!hasChanges)
                {
                    // 如果没有变化，直接关闭窗体
                    Console.WriteLine("没有检测到数据变化，直接关闭");
                    this.Close();
                    return;
                }
                
                // 显示等待光标
                this.UseWaitCursor = true;
                UpdateStatusLabel("正在保存修改...");
                
                // 创建更新对象，保留原始数据的ID和其他必要字段
                WorkShop updatedWorkshop = new WorkShop
                {
                    Id = _originalWorkshop.Id,
                    IsDeleted = _originalWorkshop.IsDeleted,
                    CreatedBy = "admin",
                    CreatedTime = _originalWorkshop.CreatedTime,  // 保留原始创建时间
                    UpdatedBy = "张三",
                    UpdatedTime = DateTime.Now,  // 更新修改时间
                    
                    // 从控件获取更新后的值
                    Workshopcode = textEdit1.Text.Trim(),
                    Workshopname = textEdit2.Text.Trim(),
                    Workshopdescription = memoEdit1.Text.Trim(),
                    Workshopattributes = " "  // 保留原始值
                };
                
                // 将对象转换为JSON
                string jsonData = JsonConvert.SerializeObject(updatedWorkshop);

                // 调用API更新数据
                string url = "api/WorkShop/UpdateWorkShop";
                string result = await APIClientl.CallApiAsync(url, "POST", jsonData);
                
                // 验证返回数据不为空
                if (string.IsNullOrWhiteSpace(result))
                {
                    // 更新状态提示
                    UpdateStatusLabel("服务器未返回数据，请检查网络");
                    return;
                }
                
                try
                {
                    // 解析返回结果
                    dynamic response = JsonConvert.DeserializeObject<dynamic>(result);
                    
                    // 检查响应码，可能是code或Code
                    string responseCode = Convert.ToString(response?.code ?? response?.Code ?? "");
                    bool isSuccess = responseCode == "200" || responseCode == "0" || string.IsNullOrEmpty(responseCode);
                    
                    if (isSuccess)
                    {
                        UpdateStatusLabel("修改成功，正在刷新数据...");
                    }
                }
                catch
                {
                    // 忽略解析错误
                }
                
                // 触发数据更新事件
                OnDataUpdated();
                
                // 设置一个短暂的延迟，让用户看到成功提示
                await Task.Delay(300);
                
                // 关闭窗体
                this.Close();
            }
            catch (Exception ex)
            {
                // 显示错误状态
                UpdateStatusLabel($"保存失败: {ex.Message}");
                Console.WriteLine($"修改失败: {ex.Message}");
                
                // 等待一会儿再关闭，让用户看到错误信息
                await Task.Delay(1000);
                
                // 尝试关闭窗口
                try
                {
                    this.Close();
                }
                catch { }
            }
            finally
            {
                // 恢复正常光标
                this.UseWaitCursor = false;
            }
        }
        /// <summary>
        /// 重置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                // 重新显示原始数据，恢复到初始状态
                DisplayWorkshopData(_originalWorkshop);
                
                // 提示用户重置成功
                UpdateStatusLabel("已重置为原始数据");
                
                // 高亮显示控件，指示已重置
                if (textEdit1 != null)
                {
                    textEdit1.BackColor = Color.LightYellow;
                }
                
                if (textEdit2 != null)
                {
                    textEdit2.BackColor = Color.LightYellow;
                }
                
                // 设置一个定时器，1秒后恢复控件的正常颜色
                Timer colorTimer = new Timer();
                colorTimer.Interval = 1000;
                colorTimer.Tick += (s, args) =>
                {
                    if (textEdit1 != null)
                    {
                        textEdit1.BackColor = SystemColors.Window;
                    }
                    
                    if (textEdit2 != null)
                    {
                        textEdit2.BackColor = SystemColors.Window;
                    }
                    
                    ((Timer)s).Stop();
                    ((Timer)s).Dispose();
                };
                colorTimer.Start();
            }
            catch (Exception ex)
            {
                // 记录异常但不显示
                Console.WriteLine($"重置数据出错: {ex.Message}");
            }
        }
    }
}